package com.gw.smscheck.util;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/**
 * 敏感词过滤
 * @author ASUS
 *
 */
public class SensitivewordFilter {
	@SuppressWarnings("rawtypes")
	public Map sensitiveWordMap = null;
	public static int minMatchTYpe = 1;      // 最小匹配规则
	public static int maxMatchType = 2;      // 最大匹配规则
	
	/**
	 * 构造函数，初始化敏感词库
	 */
	public SensitivewordFilter(){
		sensitiveWordMap = new SensitiveWordInit().initKeyWord();
	}
	
	/**
	 * 判断文字是否包含敏感字符
	 * @param txt
	 * @param matchType
	 * @return
	 */
	public boolean isContaintSensitiveWord(String txt,int matchType){
		boolean flag = false;
		for(int i = 0 ; i < txt.length() ; i++){
			int matchFlag = this.CheckSensitiveWord(txt, i, matchType); //判断文字是否包含敏感字符
			if(matchFlag > 0){    //大于0存在，返回true
				flag = true;
			}
		}
		return flag;
	}
	
	
	/**
	 * 根据 关键字集合获取匹配的关键字合集
	 * @param txt 文本
	 * @param matchType 匹配类型
	 * @return
	 */
	public Set<String> getSensitiveWordByCustomSourceWordMap(String txt , int matchType,Set<String> keyWordSet){
		Set<String> sensitiveWordList = new HashSet<String>();
		Map sensitiveWordMap = getCustomSensitiveWordMap(keyWordSet);
		for(int i = 0 ; i < txt.length() ; i++){
			int length = checkSensitiveWordByCustomSensitiveWordMap(txt, i, matchType,sensitiveWordMap); //验证敏感单词
			if(length > 0){    
				sensitiveWordList.add(txt.substring(i, i+length));
				i = i + length - 1;    
			}
		}
		
		return sensitiveWordList;
	}

	/**
	 * 获取自定义敏感词模型Map
	 * @param keyWordSet
	 * @return
	 */
	private Map getCustomSensitiveWordMap(Set<String> keyWordSet){
		//局部变量
		Map sensitiveWordMap = new HashMap(keyWordSet.size());     // 初始化敏感词容器，减少扩容操作
		String key = null;  
		Map nowMap = null;
		Map<String, String> newWorMap = null;
		// 迭代keyWordSet
		Iterator<String> iterator = keyWordSet.iterator();
		while(iterator.hasNext()){
			key = iterator.next();    // 关键字
			nowMap = sensitiveWordMap;
			for(int i = 0 ; i < key.length() ; i++){
				char keyChar = key.charAt(i);       // 转换成char型
				Object wordMap = nowMap.get(keyChar);      // 获取
				
				if(wordMap != null){        // 如果存在该key，直接赋值ֵ
					nowMap = (Map) wordMap;
				}
				else{     // 不存在则，则构建一个map，同时将isEnd设置为0，因为他不是最后一个
					newWorMap = new HashMap<String,String>();
					newWorMap.put("isEnd", "0");     // 不是最后一个
					nowMap.put(keyChar, newWorMap);
					nowMap = newWorMap;
				}
				
				if(i == key.length() - 1){
					nowMap.put("isEnd", "1");    // 最后一个
				}
			}
		}
		return sensitiveWordMap;
	}
	
	/**
	 * 根据自定义敏感词集验证字符串
	 * @param txt
	 * @param beginIndex
	 * @param matchType
	 * @param mySensitiveWordMap
	 * @return
	 */
	private int checkSensitiveWordByCustomSensitiveWordMap(String txt,int beginIndex,int matchType,Map mySensitiveWordMap){
		boolean  flag = false;     //敏感词结束标识位：用于敏感词只有1位的情况
		int matchFlag = 0;      // 匹配标识数默认为0
		char word = 0;
		Map nowMap = mySensitiveWordMap;
		for(int i = beginIndex; i < txt.length() ; i++){
			word = txt.charAt(i);
			nowMap = (Map) nowMap.get(word);     // 获取指定key
			if(nowMap != null){     // 存在，则判断是否为最后一个
				matchFlag++;      // 找到相应key，匹配标识+1
				if("1".equals(nowMap.get("isEnd"))){      // 如果为最后一个匹配规则,结束循环，返回匹配标识数   
					flag = true;       // 结束标志位为true 
					if(SensitivewordFilter.minMatchTYpe == matchType){   // 最小规则，直接返回,最大规则还需继续查找
						break;
					}
				}
			}
			else{    // 不存在，直接返回
				break;
			}
		}
		if(matchFlag < 2 || !flag){        // 长度必须大于等于1，为词
			matchFlag = 0;
		}
		return matchFlag;
	}
	
	
	
	/**
	 * 获取文字中的敏感词
	 * @param txt
	 * @param matchType
	 * @return
	 */
	public Set<String> getSensitiveWord(String txt , int matchType){
		Set<String> sensitiveWordList = new HashSet<String>();
		
		for(int i = 0 ; i < txt.length() ; i++){
			int length = CheckSensitiveWord(txt, i, matchType); //验证敏感单词
			if(length > 0){    
				sensitiveWordList.add(txt.substring(i, i+length));
				i = i + length - 1;    
			}
		}
		
		return sensitiveWordList;
	}
	
	/**
	 * 替换敏感字字符
	 * @param txt
	 * @param matchType
	 * @param replaceChar
	 * @return
	 */
	public String replaceSensitiveWord(String txt,int matchType,String replaceChar){
		String resultTxt = txt;
		Set<String> set = getSensitiveWord(txt, matchType);     //获取所有的敏感词
		Iterator<String> iterator = set.iterator();
		String word = null;
		String replaceString = null;
		while (iterator.hasNext()) {
			word = iterator.next();
			replaceString = getReplaceChars(replaceChar, word.length());
			resultTxt = resultTxt.replaceAll(word, replaceString);
		}
		
		return resultTxt;
	}
	
	/**
	 * 获取替换字符串
	 * @param replaceChar
	 * @param length
	 * @return
	 */
	private String getReplaceChars(String replaceChar,int length){
		String resultReplace = replaceChar;
		for(int i = 1 ; i < length ; i++){
			resultReplace += replaceChar;
		}
		
		return resultReplace;
	}
	
	/**
	 * 检查文字中是否包含敏感字符，检查规则如下
	 * @param txt
	 * @param beginIndex
	 * @param matchType
	 * @return 如果存在，则返回敏感词字符的长度，不存在返回0
	 */
	@SuppressWarnings({ "rawtypes"})
	public int checkSensitiveWordByWordMap(String txt,int beginIndex,int matchType){
		boolean  flag = false;     //敏感词结束标识位：用于敏感词只有1位的情况
		int matchFlag = 0;      // 匹配标识数默认为0
		char word = 0;
		Map nowMap = sensitiveWordMap;
		for(int i = beginIndex; i < txt.length() ; i++){
			word = txt.charAt(i);
			nowMap = (Map) nowMap.get(word);     // 获取指定key
			if(nowMap != null){     // 存在，则判断是否为最后一个
				matchFlag++;      // 找到相应key，匹配标识+1
				if("1".equals(nowMap.get("isEnd"))){      // 如果为最后一个匹配规则,结束循环，返回匹配标识数   
					flag = true;       // 结束标志位为true 
					if(SensitivewordFilter.minMatchTYpe == matchType){   // 最小规则，直接返回,最大规则还需继续查找
						break;
					}
				}
			}
			else{    // 不存在，直接返回
				break;
			}
		}
		if(matchFlag < 2 || !flag){        // 长度必须大于等于1，为词
			matchFlag = 0;
		}
		return matchFlag;
	}
	/**
	 * 检查文字中是否包含敏感字符，检查规则如下
	 * @param txt
	 * @param beginIndex
	 * @param matchType
	 * @return 如果存在，则返回敏感词字符的长度，不存在返回0
	 */
	@SuppressWarnings({ "rawtypes"})
	public int CheckSensitiveWord(String txt,int beginIndex,int matchType){
		boolean  flag = false;     //敏感词结束标识位：用于敏感词只有1位的情况
		int matchFlag = 0;      // 匹配标识数默认为0
		char word = 0;
		Map nowMap = sensitiveWordMap;
		for(int i = beginIndex; i < txt.length() ; i++){
			word = txt.charAt(i);
			nowMap = (Map) nowMap.get(word);     // 获取指定key
			if(nowMap != null){     // 存在，则判断是否为最后一个
				matchFlag++;      // 找到相应key，匹配标识+1
				if("1".equals(nowMap.get("isEnd"))){      // 如果为最后一个匹配规则,结束循环，返回匹配标识数   
					flag = true;       // 结束标志位为true 
					if(SensitivewordFilter.minMatchTYpe == matchType){   // 最小规则，直接返回,最大规则还需继续查找
						break;
					}
				}
			}
			else{    // 不存在，直接返回
				break;
			}
		}
		if(matchFlag < 2 || !flag){        // 长度必须大于等于1，为词
			matchFlag = 0;
		}
		return matchFlag;
	}
	
	public static void main(String[] args) {
		SensitivewordFilter filter = new SensitivewordFilter();
		System.out.println("敏感词的数量：" + filter.sensitiveWordMap.size());
		String string = "̫难过就躺在某一个人的怀里尽情的阐述心扉或者手机卡复成人游戏成人视频宝石之轮制器一个人一杯红酒一部电影在夜三级片 深人静的晚上，关上电话静静的发呆着。你是中国复兴党,中国人民 万岁";
		System.out.println("待检测语句字数：" + string.length());
		long beginTime = System.currentTimeMillis();
		Set<String> set = filter.getSensitiveWord(string, 1);
		long endTime = System.currentTimeMillis();
		System.out.println("语句中包含敏感词的个数为：" + set.size() + "。包含：" + set);
		System.out.println("总共消耗时间为：" + (endTime - beginTime));
	}
}
